<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <div class="box">
        <h2>ECMAscript:</h2>
        基本包装类型：
        把简单的数据类型包装成复杂的数据类型，这样基本数据类型就有了属性和方法；
        1.生成临时变量，把简单类型包装为复杂类型
        var temp = new Sting("xxx");
        2.赋值
        str = temp;
        3.销毁
        temp= null;
        ------------------------------------------------
        1 =true 0 =false
        《========》（逻辑运算符）
        1.逻辑与 && （and） 两侧都为true==》结果才是true ；一个为假结果就是假
        2.逻辑或 || （or） 一侧为true==》结果为true ; 两个为假结果为假
        3.逻辑非 ! （not） ==》（取反符号）
        4.逻辑与（短路运算） 如果表达式1 为真则返回表达式2 （123 && 456）===》456
        如果表达式为假则返回表达式1 （0 && 123） ===》0
        5.逻辑或（短路运算） 如果表达式1 为真返回表达式1 （1 && 2）===》1
        如果表达式1 为假发挥表达式2 （0 && 1）===》1


        for循环的执行过程：
        <!-- for(var i =1;i<10;i++){ 1. i=1 ; i<10; i=1+1 =2;i=2 
            2.i=2 ; i<10; i=2+1=3 ；i=3 
            3.i=3 ;i<10 ;i=3+1=4 ;i =4
            .....
            9. i=9; i<10; i=9+1=10;i=10
            第十次结束不满足条件没有返回值；
        } -->

        2.标识符的命名规范：
        变量函数名命名必须要有意义；
        变量的名称一般用 名词
        函数的名称一般用 动词

        while循环:
        当。。。。时候
        为真的时候执行循环体;否则退出循环体
        while(true){
        执行代码;
        }

        循环关键字：
        break==》退出当前循环体
        continue==>跳出本次循环，继续执行下次循环
        return==》可以跳出循环，还能够返回return的结果

        数组:for...of遍历数组
        1：作用存放多个数据
        2：数组的概念:一组数据的集合
        3: 创建数组的方式:{1.var xxx = new Array();2. var xxx=[];}
        4: 获取数组的元素: 1.数组的索引（下标==》index）从零开始 ==》访问设置修改数组
        5: 遍历数组: for i in array{} 索引递增===》for循环的递增
        6: 数组元素的个数获取 数组.length; 数组的长度是元素的个数！=索引
        7: 数组对象 ===>判断是否为数组==》数组 instanceof Array ==》true/false
        8:数组的方法:
        1.添加元素:
        arr.push(在数组后面添加);
        arr.unshift(在数组的前面添加元素);
        2.删除元素
        arr.pop(在数组后面删除);
        arr.shift(在数组的前面删除,删除第一个元素)
        3.数组转换为字符串：arr.toString(); String(arr); arr.join("")==>里面填写分隔符
        4.连接两个数组(数组合并)==》arr.concat(arr2); ===>改变数组长度返回一个新数组
        5.数组截取===》arr.slice(start,end)[查找索引【start，end)];===》返回新数组==》不影响长度
        6.数组删除===》arr.splice("从第几个开始","要删除的个数")(不包含最后一项);===>返回新数组==》影响数组长度

        函数:function(){};===》封装了一段可以重复调用的代码块，目的实现代码的复用
        1.声明函数==》function 函数名(){}; 使用:函数名();
        2.函数的参数:1.形参2.实参{ function函数名（形参）{}; 函数名（实参）} 形参是接收实参的
        3.做某件事或者实现某一种功能
        4。函数的返回值（return）===>我们的函数只是实现某种功能，最终的结果要返回给函数的调用者函数名();
        4-1[return ==》终止函数（return后的代码不会执行）===》return只能返回一个值]
        5.arguments==>存储了所有传递过来的实参（伪数组）==》可以进行遍历==》具有
        1.数组的长度属性 2.可以按索引的方式存数据 3.不具有数组的方法
        6.函数的互相调用 （函数调用函数）
        7.函数的两种声明方式：1.关键字声明 2.函数表达式(匿名函数)（var 变量名=function(){};）

        js的作用域（变量的范围,提高程序的可靠性）:
        1.全局作用域:整个script标签
        2.局部作用域:函数内部起效果和作用
        3.全局变量和局部变量（未声明的变量也属于全局变量默认是undifind）
        4.函数的(形参)也可以看成是局部变量===>全局变量占内存不会自动销毁,局部变量执行完毕后进行自动销毁(节约内存)
        5.块级作用域 (花括号)=={},没有作用域的使用范围
        6.作用域链==》内部函数可以使用外部函数（就近原则）

        js预解析
        1.变量提升==》只提升变量不进行赋值，全部提升到作用域的最前面

        对象:
        1.对象是一个具体事物，是一组无序相关属性和方法的集合
        2.创建对象 var a={} ===》属性:属性值,方法后面跟的是匿名函数
        3.构造函数:是一种特殊的函数，用来初始化对象。提取对象的一些公共的属性
        和方法，放后封装的函数
        4.构造函数的语法格式:function 构造函数名(){ this.属行=值; this.方法=function(){}}; 使用:new 构造函数();
        5.构造函数的名字首字母要大写,new 一个函数就等于创建了一个对象,属性和方法面前必须加this关键字
        6.我们利用构造函数创建对象的过程称为实例化（对象的实例化）====》new 对象的过程称之为(实例化)
        7.new构造函数执行过程:1.首先创建一个空对象 2.用this关键字指向空对象 3.给空对象里面添加属性和方法 4.返回这个对象（new）===》构造函数不需要return
        8.遍历对象 for。。。in

        js的内置对象:
        1.js对象的分类:1.自定义对象 2.内置对象 3.浏览器对象
        2.math对象:1-绝对值:math.abs(); 2-取整:math.floor()===>向下取整(取小)
        3-math.ceil()==>向上取整（取大）4-math.round()====>四舍五入
        5-math.random()==》随机数
        3.date对象:必须使用new来调用，是一个实例化对象，是一个构造函数
        2.使用 var date =new Date();===>返回当前时间日期年份
        4.string对象:
        str对象的方法:
        1.更据字符返回位置
        str.indexof("要查找的字符",[起始位置])
        2.字符串方法
        合并
        1.str.concat(xxxx);
        截取
        2.str.substr(截取的位置,截取的个数)
        替换（只会替换第一个字符）
        3.str.replace("被替换的字符",替换为的字符)
        字符转换为数组
        4.str.split("分隔符")
        5.str.toUpperCase()转换为大写
        6.str.toLowerCase()转换为小写
        <hr>
        <h2>DOM</h2>
        1.DOM可以改变网页的内容样式和结构
        2.获取元素
        （1）通过id获取:{
        1.document.getelementByid("id字符串");
        console.dir() 可以打印返回的元素对象直观查看元素的属性和方法
        }
        （2）通过标签名获取:{
        1.document.getelementByTagName("") ===>返回对象的集合
        2.父元素的获取必须是单一的元素 可以使用【0】==》来取
        }
        （3）通过HTML5方法获取:{
        document.getelementByClassName("")
        }
        （4）通过特殊的元素获取:{
        1.获取body元素:document.body;==>返回的是一个body元素对象
        2.获取html元素:document.documentElement;返回的是一个html元素对象
        }
        ****&（5）document.querySelector("选择器")==》返回元素的第一个对象
        （6）document.querySelectorAll("选择器")==》返回元素所有的对象
        3.事件(行为==》响应)===》事件处理程序==》通过函数赋值的方式完成:{
        1.执行事件的步骤：
        }
        4.操作元素:{
        1.改变元素的内容：{element.innerText;
        element.innerHtml;
        2.修改元素的属性
        3.修改表单属性
        4.修改元素的样式属性
        }
        5.this的指向:(1).指向当前事件函数的调用者 （2）.
        }
        6.input.onfocus()==>获取焦点； input.onblur()==>失去焦点
        7.利用className修改样式属性 ，element.className="class"(样式写在style)
        8.排他思想:1.给所有元素全部清除样式（干掉其他人）2.给当前元素设置样式（留下自己）
        9.自定义属性:{
        自定义属性的目的：保存并且使用数据
        H5定义标准：所有的自定义属性都必须以data-xxx开头;
        H5新增的火气自定义属性的方法: element.dataset.属性
        dataset====》是一个对象，里面存储了所有的属性
        1.获取属性值:element.属性 :获取属性值 ===》获取元素的内置属性
        2.element.getAttribute("属性") ==》获取自定义的属性值
        3.设置属性值: element.属性="值";
        4.element.setAttribute("属性","值");
        }
        10.节点操作:{
        1.利用DOM提供的方法获取元素
        2.利用节点的层级关系获取元素:{
        1.利用父子兄节点获取元素 2.逻辑性强，但兼容性差
        }
        }
        11.父级节点 （element.parentNode）==>获取的是距离元素最近的父节点==找不到就赋值为null
        12.子节点{
        （element.childNodes）==(element.children 只获取到元素节点（伪数组）)===>获取的是一个集合,伪数组(包含的是所有节点,文本+元素)
        （element.firstChild）===>获取元素的第一个子节点（文本+元素）;（element.lastChild）===>获取元素最后一个子节点（文本+元素）
        （element.fristElementChild）==>获取元素第一个子元素节点,（element.lastElementChild）==>获取元素最后一个子元素节点
        }
        13.兄弟节点: 1.element.nextSibling(包含文字+元素)==》获得下一个兄弟节点==》element.nextElementSibling(获得下一个兄弟元素节点)
        2.element.previouSibling(包含文字+元素)==》获得上一个兄弟节点==》element.previousElementSibling(获得上一个兄弟元素节点)
        14.创建节点:document.createElement("要创建的节点");
        15.添加节点:父级节点.appendChild("要添加的节点");===>插入到后面； 父级节点.inserBefore("要添加的节点"，"指定要添加的位置");===>插入到前面
        16.删除节点:父级节点.removeChild（"要删除的子节点"）;
        17.复制节点:element.cloneNode();===>浅拷贝==》只复制结构不复制内容,不改变原来的状态（false）;深拷贝==》复制结构和内容，改变原来的状态（true）;

        <h3>18事件高级</h3>
        1.事件监听注册：evenTarget（元素）.addEventLister("事件处理方式",执行函数事件)
        2.ie9以下版本兼容===》ele.attachEvent('事件处理方式',fn)
        事件注册==》解绑事件（ele.事件处理方式=null）
        3.方法监听解绑注册的方式==》evenTarget.removeEventListener("事件处理方式（type),对象,fn")
        4.Dom事件流: 1.捕获阶段 2.当前阶段 3.冒泡阶段（阻止事件冒泡）
        5.事件对象: event就是一个事件对象 写到监听函数的小括号里，作为形参
        6.事件对象的常用属性和方法:
        e.target || e.srcElement===>(返回触发事件的对象),e.type
        阻止事件冒泡: e.preventDefault();阻止默认行为：例如链接的自动跳转
        阻止冒泡:e.stopPropageation();
        7.事件委托:给父节点添加事件监听器，通过冒泡来监听子节点
        8.onkeyup,onkeydown(不区分大小写);onkeypass(区分大小写)
        9.keyboard==>获取当前按键的ASCII码
        <hr>
        <h2>BOM浏览器对象</h2>
        BOM对象<h4>{window}</h4>包含[(dom)--(location)--(navigation)--(screen)--(history)];
        【1】window对象常用的事件:
        1.加载事件=window.onload();
        2.调整窗口大小事件=window.onsize();==>响应式布局页面==》页面加载完成后开始执行
        3.定时器:（时间到了执行）setTimeout();===============》停止定时器: clear.Timeout(要关闭的定时器);
        重复调用定时器：setInterval();一直调用
        4.回调函数==》callback===》回头调用的函数
        5.this指向：{1.全局对象this指向window对象 2.this指向事件（方法）的调用者}
        6.js执行队列:同步（单线程），异步（多线程同一时间执行）
        执行机制:先执行栈中的同步任务，在执行消息队列的回调函数（异步任务）
        事件循环==》主线获取任务执行，在获取任务在执行，这样重复叫做（事件循环）
        <h4>7.location对象:</h4>
        (1)获取或者设置窗口的url，并且解析url;
        1.location.href(获取网址)
        2.location.host(获取主机名)
        3.location.port(返回端口号)
        4.location.pathname(返回路径)
        5.location.search(返回参数)
        6.location.hash(返回链接)
        7.location.assign(链接)===》记录历史可以回退页面
        8.location.replace()===>不记录历史
        9.location.reload()====>true 自动刷新;默认false不刷新;
        <h4>8.navigator对象:</h4>
        navigator.userAgent===>实现跨端页面跳转（pc==》移动）
    </div>
</body>
<script src="./js库.js"></script>
<script>
    // var name =prompt("请输入你的名字");
    // var age =prompt("请输入你的年龄");
    // var sex =prompt("请输入你的性别");
    // var str = `你的名字是:${name}
    // 你的年龄是:${age}
    // 你的性别是:${sex}`;
    // console.log(str);
    // var user =prompt("请输入中奖人的姓名");
    // if(user == "刘德华"){
    //     alert("恭喜你中了5元")
    // }else{
    //     alert(" not")
    // }


    /*判断当前时间值（特定数值）  */
    // var times = prompt("请输入当前时间:");
    // switch (times) {
    //     case "12": alert("中午好"); break;
    //     case "18": alert("晚上好"); break;
    //     case "23": alert("深夜好"); break;
    //     default: alert("xxxxx")
    // }

    /* 判断最大值 */
    // var val1 = prompt("请输入第一个值:");
    // var val2 = prompt("请输入第二个值:");
    // var num = var1 < val2 ? val2 : val1;
    // alert(num);

    // 循环
    /* for 循环 ==》while 循环 ==》do 。。。 while循环 */

    // for("初始化变量";"条件表达式";"操作表达式"){
    //     "循环体"
    // }
    // 初始化变量拿来计数
    // for(i=1;i<=10;i++){
    //     console.log(i);
    // }

    /* 1-100的和 */
    /*     var sum = 0;
        for (var i = 1; i <= 100; i++) {
            sum += i;
            // sum = sum + i
        }
        console.log(sum); */

    /* 1-100的平均数 */
    /*     var sum2 = 0; //he
        var advange = 0; //pingjunshu
        for (var i = 1; i <= 100; i++) {
            sum2 += i;
        }
        advange = sum2 / 100;
        console.log(advange); */

    /* 1-100之间所有偶数和奇数德和 */
    /*     var odd = 0;
        var even = 0;
        for (var i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                // even = even + i;
                even += i;
                // console.log(ji);
                // 所有偶数的和
            } else {
                odd += i;
                // console.log(o);
                // 所有奇数的和
            }
        }
        console.log(odd);
        console.log(even); */

    /* 1-100之间所有能被3整除数字的和 */
    /*     var Num = 0;
        for (var i = 1; i <= 100; i++) {
            if (i % 3 == 0) {
                Num += i;
            }
        }
        console.log(Num); */

    /*计算班级成绩平均分和总和 */
    /* 效果演示：输入人数后，弹出输入人数的提示框 */
    // var people = prompt("请输入班级总人数:")
    // var sum = 0; //和
    // var adv = 0;  //平均值
    // for (var i = 1; i <= people; i++) {
    //     //分数
    //     var score = prompt(i);
    //     sum += parseFloat(score)
    // }
    // console.log(sum);
    // adv = sum / people
    // console.log(adv);

    // 5行打印5个星星
    /*   var str = "";
      // 行
      for (var i = 1; i <= 5; i++) {
          // 列
          for (var j = 1; j <= 5; j++) {
              str = str + "★"
          }
          str = str + "★" + "\n"
      }
      console.log(str); */

    //倒立的三角形
    // var str2 = "";
    // for (var i = 10; i >= 0; i--) {
    //     for (var j = 1; j <= i; j++) {
    //         // 行
    //         str2 = str2 + "◆"
    //     }
    //     // 列
    //     str2 = str2 + "◆" + "\n"
    // }
    // console.log(str2);

    //正三角形
    /*   var str3 = "";
      for (var i = 1; i <= 10; i++) {
          str3 = str3 + "◆" + "\n"
          for (var j = 1; j <= i; j++) {
              str3 = str3 + "◆"
          }
      }
      console.log(str3); */

    // n行n列的星星
    /*     var hang = prompt("xxxxhang个");
        var lie = prompt("xxxxlie个");
        var str4 = "";
        for (var i = 1; i <= hang; i++) {
            for (var j = 1; j <= lie; j++) {
                str4 = str4 + "★"
            }
            str4 = str4 + "\n"
        }
        console.log(str4); */

    // 九九乘法表
    /*     var sum = "";
        for (var i = 1; i <= 9; i++) {
            // 行
            for (var j = 1; j <= i; j++) {
                // 列           1X1=1 (拼接字符串)
                sum += i + "×" + j + "=" + i * j + "\t";
            }
            sum += "\n"
        }
        console.log(sum); */

    /* 1-100除了能被7整除之外的整数和 */
    /*     var sum2 = 0;
        for (var i = 1; i <= 100; i++) {
            if (i % 7 == 0) {
                continue;
            }
            sum2 += i
        }
        console.log(sum2);
    
        /*吃包子案例  */
    /*    for (var i = 1; i <= 5; i++) {
           if (i == 3) {
               break;
           }
           console.log("我正在吃" + i + "包子");
           // console.log(i);
       } */
    //结果：1,2,3之后的结果不会执行

    /*简易的ATM机  */
    //做选择做操作==》用while
    /*     var savemoney = 100;
        while (true) {
            var money = prompt("请输入你要的操作:\n 1.存钱\n 2.取钱\n 3.显示余额\n 4.退出");
            if (money == 1) {
                var getmoney = prompt("请输入存的钱数:");
                savemoney += parseInt(getmoney)
                alert("您现在的钱数是:" + savemoney + "元")
                continue;
            } else if (money == 2) {
                var putmoney = prompt("请输入拿取的钱数:");
                savemoney -= parseInt(putmoney);
                alert("您目前还剩下" + savemoney + "元");
            } else if (money == 3) {
                alert("您当前还剩下:" + savemoney + "元")
            } else if (money == 4) {
                alert("您正在退出......")
                break
            }
        } */

    /*数组*/
    /*    var day = [1, 2, 3, 4, 5, 6, "星期天"];
       for (var i = 0; i < 7; i++) {
           console.log(day[i]);
       };
       var sanguo = ["关羽", "张飞", "马超", "赵云", "黄忠", "刘备", "姜维"];
       for (var i = 0; i < sanguo; i++) {
           console.log(sanguo[i]);
       } */
    /* 计算数组的和与平均数 */
    var sum4 = 0;
    var average = 0;
    var a = [2, 6, 1, 7, 4];
    for (var i = 0; i < a.length; i++) {
        sum4 += a[i] //计数器(索引i);数组元素是a[i] 
    }
    average = sum4 / a.length;
    console.log(sum4);
    console.log(average);

    /* 数组的最大值 */
    var b = [2, 6, 77, 1, 52, 25, 7];
    var max = b[0];
    for (var i = 0; i < b.length; i++) {
        if (max < b[i]) {
            max = b[i]
        }
    }
    console.log(max);

    /* 数组转换切割字符串 */
    var color = ["red", "green", "yellow"];
    var str = "";
    var step = "*"
    for (var i = 0; i < color.length; i++) {
        str += color[i] + step;
    }
    console.log(str);

    /* 数组的新增元素 */
    var c = [];
    for (var i = 0; i < 10; i++) {
        // c += i; //(c = c + i)
        c[i] = i + 1;

    }
    console.log(c);

    /* 筛选数组 */
    var d = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7];
    var j = 0;//新数组索引的计数
    var e = [];
    for (var i = 0; i < d.length; i++) {
        if (d[i] >= 10) {
            // 新数组索引应该从零开始递增【0】
            e[j] = d[i]
            j++;
        }
    }
    console.log(e);

    var d1 = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7];
    var e1 = [];//新数组默认长度为零
    for (var i = 0; i < d1.length; i++) {
        if (d1[i] >= 10) {
            // 新数组索引应该从零开始递增【0】
            e1[e1.length] = d1[i]
        }
    }
    console.log(e1);

    /* 删除指定数组 */
    var d2 = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7];
    var e3 = [];
    for (var i = 0; i < d2.length; i++) {
        if (d2[i] != 0) {
            e3[e3.length] = d2[i]
        }
    }
    console.log(e3);

    /* 反转数组 */
    var color2 = ["red", "green", "yellow"];
    var newArr = [];
    for (var i = color2.length - 1; i >= 0; i--) {
        newArr[newArr.length] = color2[i]
    }
    console.log(newArr);

    /* 冒泡排序 */
    // var f = [1, 34, 45, 67, 88, 100, 2, 3, 46, 56, 5, 6, 8, 9, 10];
    var temp = "";
    // for (var i = 0; i <= f.length - 1; i++) {
    //     // 外层循环管趟数
    //     for (var j = 0; j <= f.length - 1 - i; j++) {
    //         if (f[j] < f[j + 1]) {
    //             temp = f[j];
    //             f[j] = f[j + 1]
    //             f[j + 1] = temp
    //         }
    //     }
    // }
    // console.log(f);
    var arr2 = [5, 4, 3, 2, 1, 0];
    /* 
        5,4= =4,5
        5,3==4,3,5
        5,2==4,3,2,5
        5,1==4,3,2,1,5
        5,0==4,3,2,1,0,5
    */
    for (var i = 0; i <= arr2.length - 1; i++) {
        // 五趟
        for (var j = 0; j <= arr2.length - 1 - i; j++) {
            if (arr2[j] < arr2[j + 1]) {
                temp = arr2[j];
                arr2[j] = arr2[j + 1]
                arr2[j + 1] = temp;
            }
        }

    }
    console.log(arr2);
    // ===================================================
    var result = getSum(100, 1000);
    console.log(result);
    console.log(getMax(1, 3));
    console.log(getArrMax([1, 2, 4, 5, 6, 10]));
    var result3 = getMValue(1, 33, 45, 12)
    console.log(result3);
    console.log(reverse([1, 2, 3, 4, 5, 6, 7, 8]));
    console.log(sort([1, 10, 2, 23, 445, 677, 3, 2]));
    // var result4 = isRunYear(1999);
    // console.log(result4);
    var result4 = isRunYear(2000);
    console.log(result4);

    /* js预解析 */
    f1();
    console.log(a);
    console.log(b);
    console.log(c);
    function f1() {
        var a = b = c = 9;
        console.log(a);
        console.log(b);
        console.log(c);
    }
    /* 解析： 首先看是否有变量提升，这里是函数提升
     1. function f1(){
         var a=;
         var a=b=c=9 == var a=9; b=9; c=9
         b,c属于全局变量

        console.log(a) =====9
        console.log(b) =====9
        console.log(c) =====9
        };
    f1();
        console.log(a) 没申明没定义===》报错
        console.log(b) 9
        console.log(c) 9
        */

    /*对象*/
    var dog = {
        dogName: "可可",
        type: "阿拉斯加犬",
        age: 5,
        color: "棕红色",
        skil: function () {
            console.log("bark");
            console.log("showFilm");
        }
    }
    console.log(dog);

    /* 构造函数 */
    function hero(name, type, blood, attack) {
        this.name = name;
        this.type = type;
        this.blood = blood;
        this.attacak = attack;
        /* class类 */
    }
    var lianpo = new hero("廉颇", "力量型", "500血量", "近战攻击");
    var houyi = new hero("后羿", "射手型", "100血量", "远程攻击");
    console.log(lianpo, houyi);
    /* for....in 遍历对象 */
    var sot = { name: "wo" }
    for (var i in sot) {
        console.log(sot[i]);
    }

    /* 随机点名 */
    var arr3 = ["li", "wang", "xiao", "long", "wu", "yan"];
    function getRandom(min, max) {
        return Math.floor(Math.random() * (max - min + 1)) + min
    }
    console.log(arr3[getRandom(0, arr3.length - 1)]);

    /* 猜数字 ===简简单单*/
    // var random = getRandom(1, 10);
    // while (true) {
    //     // 死循环
    //     var answer = prompt("请随机输入1-10范围之间的数字:")
    //     if (answer > random) {
    //         alert("数字大了，请继续猜！")
    //     } else if (answer < random) {
    //         alert("数字小了，请继续猜!")
    //     } else {
    //         alert("恭喜你猜对了,接下来会自动结束程序");
    //         break;
    //     }
    // }


    /* 日期对象 */
    var date = new Date();
    var year = date.getFullYear();
    var month = date.getMonth() + 1;
    var day = date.getDate();
    var week = date.getDay()
    console.log(year, month, day, week);
    var nowTime = year + "年" + month + "月" + day + "日" + "星期" + week;
    console.log(nowTime);
    /*格式化日期（时分秒）  */
    var date = new Date();
    var hour = date.getHours();
    var min = date.getMinutes();
    var sec = date.getSeconds();
    console.log(hour, min, sec);
    /* ------------------------------------------------------------ */
    function getTime() {
        var time = new Date();
        var hour = time.getHours();
        hour = hour < 10 ? "0" + hour : hour;
        var min = time.getMinutes();
        min = min < 10 ? "0" + min : min
        var sec = time.getSeconds();
        sec = sec < 10 ? "0" + sec : sec
        return hour + ":" + min + ":" + sec;
    }
    console.log(getTime());
    // 获取时间戳
    console.log(Date.now());

    // 倒计时:
    function countDown(time) {
        var oldTime = +new Date();   //当前时间
        var nowTime = +new Date(time); //预计时间
        var times = (nowTime - oldTime) / 1000; //总的秒数==》预计时间-当前时间
        var day = parseInt(times / 60 / 60 / 24); //天
        var hour = parseInt(times / 60 / 60 % 24); //时
        var min = parseInt(times / 60 % 60);    //分
        var sec = parseInt(times % 60);         //当前秒
        return day + "天" + hour + "时" + min + "分" + sec + "秒"
    }
    // 传入一个时间戳
    console.log(countDown("2021-10-24 24:00:00"));

    /* 筛选数组 */
    var nGz = [];
    var gz = [1500, 1200, 2000, 2100, 1800];
    for (var i = 0; i <= gz.length; i++) {
        if (gz[i] < 2000) {
            nGz.push(gz[i])
        }
    }
    console.log(nGz);

    /* 反转数组 */
    console.log(gz.reverse());
    /* 冒泡排序 */
    console.log(gz.sort(function (a, b) {
        return a - b  //升序排列
        // return b - a //降序排列
    }));
    // 数组的索引
    console.log(gz.indexOf());

    /* 数组去重 */
    var bigArr = ["a", "b", "c", "a", "z"];
    console.log(unique(bigArr));

    /* 数组转为字符串 */
    var num4 = [1, 2, 3, 4, 5, 5, 6, 7];
    console.log(num4.toString());
    console.log(num4.join(" "));

    /* 数组合并 */
    var _a = [1, 2, 23, 4, 5];
    var _b = [1, 1, 1, 1, 1, 12, 3];
    console.log(_a.concat(_b));
    console.log(_a.slice(1, 3));
    console.log(_b.splice(0, 5));

    /* 查找字符串 */
    var str4 = "oabcoefoxyozzopp";
    var index = str4.indexOf("o");
    var op = 0;
    while (index != -1) {
        op++;
        index = str4.indexOf("o", index + 1)
    }
    console.log(op);

    //     var color3 = ["red", "blue", "green", "red"];
    //     var num5 = 0;
    //     for (var i = 0; i < color3.length; i++) {
    //         if (color3.indexOf("red") != -1) {
    //             num5++;
    //             color3.indexOf("red",    + 1)
    //         }
    //     }
    // console.log(num5);

    /* 返回字符位置 */
    var str5 = "abcoefoxyozzopp";
    var v = {};
    for (var i = 0; i < str5.length; i++) {
        var chars = str.charAt(i);
        //chars是字符串的每一个字符v
        if (v[chars]) {
            v[chars]++;
        } else {
            v[chars] = 1;
        }
    }
    console.log(v);

    //兼容性:
    function JR(e) {
        e = e || window.event;
        var target = e.target || e.srcElement;
        return e;
    }
</script>

</html>